Auto1 Data Science Challenge
Agenda¶
- Business Understanding
- Data Understanding
- Data Preparation
- Exploratory Data Analysis
- Building a Random Forest Model
- Evaluation
Business Understanding¶
A leading car trading company which connects both sellers and buyers through a online trading platform wants to analyze their data to improve its business.
Problem Statement¶
The objectives is to :
- Building a regression model to predict the price of a car given the car features amd insurance related features.
- Building a regression model to predict the normalized-losses of a car based on the car faetures.
Data Understanding¶
In [2]:
# Importing libraries
import pandas as pd
import numpy as np
import missingno as msno
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from fancyimpute import KNN
import itertools
import graphviz
import shap
import os
os.environ["PATH"] += os.pathsep + 'C:/Program Files (x86)/graphviz-2.38/release/bin/'
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn import tree
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor
import xgboost as xgb
from sklearn.metrics import mean_absolute_error, r2_score
In [3]:
pd.set_option('display.max_columns', None) # or 1000
pd.set_option('display.max_rows', None) # or 1000
pd.set_option('display.max_colwidth', -1) # or 199
In [65]:
# Reading the data
car_Data = pd.read_csv('Auto1-DS-TestData.csv')
In [19]:
car_Data
Out[19]:
In [5]:
car_Data.dtypes
Out[5]:
In [14]:
car_Data.describe(include = 'all')
Out[14]:
Attribute Information:¶
- symboling: -3, -2, -1, 0, 1, 2, 3.
- normalized-losses: continuous from 65 to 256.
make: alfa-romero, audi, bmw, chevrolet, dodge, honda, isuzu, jaguar, mazda, mercedes-benz, mercury, mitsubishi, nissan, peugot, plymouth, porsche, renault, saab, subaru, toyota, volkswagen, volvo
fuel-type: diesel, gas.
- aspiration: std, turbo.
- num-of-doors: four, two.
- body-style: hardtop, wagon, sedan, hatchback, convertible.
- drive-wheels: 4wd, fwd, rwd.
- engine-location: front, rear.
- wheel-base: continuous from 86.6 120.9.
- length: continuous from 141.1 to 208.1.
- width: continuous from 60.3 to 72.3.
- height: continuous from 47.8 to 59.8.
- curb-weight: continuous from 1488 to 4066.
- engine-type: dohc, dohcv, l, ohc, ohcf, ohcv, rotor.
- num-of-cylinders: eight, five, four, six, three, twelve, two.
- engine-size: continuous from 61 to 326.
- fuel-system: 1bbl, 2bbl, 4bbl, idi, mfi, mpfi, spdi, spfi.
- bore: continuous from 2.54 to 3.94.
- stroke: continuous from 2.07 to 4.17.
- compression-ratio: continuous from 7 to 23.
- horsepower: continuous from 48 to 288.
- peak-rpm: continuous from 4150 to 6600.
- city-mpg: continuous from 13 to 49.
- highway-mpg: continuous from 16 to 54.
- price: continuous from 5118 to 45400.
Data Prepration¶
Preprocessing to be done :¶
- Cleansing data
- Converting attributes to appropriate data type
Cleansing Data :
- Replacing '?' with nulls
- num-of-doors has an extra unique level ( need to replace )
In [66]:
# Replacing '?' with nulls#
car_Data = car_Data.replace('?', np.NaN)
In [6]:
# Checking for nulls
car_Data.isnull().sum()
Out[6]:
In [122]:
car_Data = car_Data.dropna(subset=['price'])
The msno.matrix nullity matrix is a data-dense display which lets you quickly visually pick out patterns in data completion.
In [25]:
msno.matrix(car_Data)
Out[25]:
From the above plot, we can see that column normalized_losses has the maximum missing values
The missingno correlation heatmap measures nullity correlation: how strongly the presence or absence of one variable affects the presence of another:
In [26]:
msno.heatmap(car_Data)
Out[26]:
There seems to be high correlation of missing values between stroke & bore and horsepower & peak-rpm.
Need to convert the following data types to its appropriate type :
- symboling to object/category
- normalized-losses to int/float
- bore, stroke, horsepower, peak-rpm and price to continous
In [123]:
car_Data['symboling'] = car_Data['symboling'].astype('object')
for column in ['normalized-losses','bore','stroke','peak-rpm','price','horsepower']:
car_Data[column] = car_Data[column].astype('float')
In [10]:
car_Data.dtypes
Out[10]:
Exploratory Data Analysis¶
Univariate Analysis¶
In [29]:
for column in car_Data.columns:
if car_Data[column].dtype in (['int64','float64']):
sns.distplot(car_Data[column].dropna(), kde=False, rug=True)
plt.show()
else:
sns.countplot(car_Data[column] ,palette="deep")
plt.xticks(rotation = 90)
plt.show()
Analysis from the above plots :
- Toyota is the make of the car which has most number of vehicles with more than 40% than the 2nd highest Nissan
- Most preferred fuel type for the customer is standard vs trubo having more than 80% of the choice
- For drive wheels, front wheel drive has most number of cars followed by rear wheel and four wheel. There are very less number of cars for four wheel drive.
- Curb weight of the cars are distributed between 1500 and 4000 approximately
- Symboling or the insurance risk rating have the ratings between -3 and 3 however for our dataset it starts from -2. There are more cars in the range of 0 and 1.
- Normalized losses which is the average loss payment per insured vehicle year is has more number of cars in the range between 65 and 150.
Bi-Variate Analysis¶
Numerical VS Numerical Features
In [31]:
sns.pairplot(car_Data.dropna())
Out[31]:
In [270]:
plt.figure(figsize=(16,16))
sns.heatmap(car_Data.corr())
plt.show()
Categorical VS Categorical Features
In [43]:
cat_Cols = car_Data.select_dtypes(include=['object']).columns
cat_Cols_Groups = list(itertools.combinations(cat_Cols, 2))
for group in cat_Cols_Groups:
sns.countplot(x = group[0], hue=group[1], data=car_Data)
plt.xticks(rotation = 90)
plt.show()
Categorical VS Numerical
- Symboling vs Numeric Features
- Price vs Categorical Features
- Normalized_loss vs Categorical Features
In [44]:
for column in car_Data.select_dtypes(include=['int64','float64']).columns:
sns.boxplot(x = 'symboling', y= column, data = car_Data)
plt.show()
In [46]:
for column in car_Data.select_dtypes(include=['object']).columns:
sns.boxplot(x = column, y= 'price', data = car_Data)
plt.show()
In [48]:
for column in car_Data.select_dtypes(include=['object']).columns:
sns.boxplot(x = column, y= 'normalized-losses', data = car_Data)
plt.show()
Data Prepration for Model Building¶
Preprocessing to be done :
- Convert categorical variables to numeric variables
- Impute missing values
- Scaling the features
In [124]:
# Convert categorical variables to numeric variables
cols_to_transform = car_Data.select_dtypes(include=['object']).columns
car_Data = pd.get_dummies(columns=cols_to_transform, data=car_Data, prefix=cols_to_transform, prefix_sep='_', drop_first=True)
In [125]:
cols = car_Data.columns
print(cols)
In [126]:
car_Data.head()
Out[126]:
In [127]:
car_Data_Imputed = pd.DataFrame(KNN(3).fit_transform(car_Data))
In [128]:
car_Data_Imputed.columns = cols
In [129]:
# Checking for nulls
car_Data_Imputed.isnull().sum()
Out[129]:
In [248]:
cols_to_transform
Out[248]:
In [249]:
# Scaling the features
num_Cols = [x for x in car_Data_Imputed.columns if x not in ['symboling_-1', 'symboling_0', 'symboling_1', 'symboling_2', 'symboling_3', 'make_bmw', 'make_chevrolet', 'make_dodge', 'make_honda', 'make_isuzu', 'make_jaguar', 'make_mazda', 'make_mercedes-benz', 'make_mercury', 'make_mitsubishi', 'make_nissan', 'make_peugot', 'make_plymouth', 'make_porsche', 'make_renault', 'make_saab', 'make_subaru', 'make_toyota', 'make_volkswagen', 'make_volvo', 'fuel-type_gas','aspiration_turbo', 'num-of-doors_two', 'body-style_hardtop', 'body-style_hatchback', 'body-style_sedan', 'body-style_wagon', 'drive-wheels_fwd', 'drive-wheels_rwd', 'engine-location_rear', 'engine-type_l', 'engine-type_ohc', 'engine-type_ohcf', 'engine-type_ohcv', 'engine-type_rotor', 'num-of-cylinders_five', 'num-of-cylinders_four', 'num-of-cylinders_six', 'num-of-cylinders_three', 'num-of-cylinders_twelve', 'num-of-cylinders_two', 'fuel-system_2bbl', 'fuel-system_4bbl', 'fuel-system_idi', 'fuel-system_mfi', 'fuel-system_mpfi', 'fuel-system_spdi', 'fuel-system_spfi']]
cat_Cols = ['symboling_-1', 'symboling_0', 'symboling_1', 'symboling_2', 'symboling_3', 'make_bmw', 'make_chevrolet', 'make_dodge', 'make_honda', 'make_isuzu', 'make_jaguar', 'make_mazda', 'make_mercedes-benz', 'make_mercury', 'make_mitsubishi', 'make_nissan', 'make_peugot', 'make_plymouth', 'make_porsche', 'make_renault', 'make_saab', 'make_subaru', 'make_toyota', 'make_volkswagen', 'make_volvo', 'fuel-type_gas','aspiration_turbo', 'num-of-doors_two', 'body-style_hardtop', 'body-style_hatchback', 'body-style_sedan', 'body-style_wagon', 'drive-wheels_fwd', 'drive-wheels_rwd', 'engine-location_rear', 'engine-type_l', 'engine-type_ohc', 'engine-type_ohcf', 'engine-type_ohcv', 'engine-type_rotor', 'num-of-cylinders_five', 'num-of-cylinders_four', 'num-of-cylinders_six', 'num-of-cylinders_three', 'num-of-cylinders_twelve', 'num-of-cylinders_two', 'fuel-system_2bbl', 'fuel-system_4bbl', 'fuel-system_idi', 'fuel-system_mfi', 'fuel-system_mpfi', 'fuel-system_spdi', 'fuel-system_spfi']
scaler = StandardScaler()
price = car_Data_Imputed.price
car_Num_Data = car_Data_Imputed[num_Cols]
car_Cat_Data = car_Data_Imputed[cat_Cols]
car_Data_Scaled = pd.DataFrame(scaler.fit_transform(car_Num_Data))
car_Data_Scaled.columns = num_Cols
In [251]:
car_Data_Scaled = pd.concat([car_Data_Scaled, car_Cat_Data], axis=1)
#car_Data_Scaled.columns = cols
car_Data_Scaled['price'] = price
In [252]:
car_Data_Scaled.head()
Out[252]:
Split the data into Train and Test
In [276]:
X, y = car_Data_Scaled.loc[:, car_Data_Scaled.columns!='price'].values, car_Data_Scaled.loc[:,'price'].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=15)
Starting with a simple model !!!
Linear Regression¶
In [254]:
linReg = LinearRegression()
# create the RFE model for the svm classifier
# and select attributes
linear_Model = linReg.fit(X_train, y_train)
y_train_pred = linear_Model.predict(X_train)
y_test_pred = linear_Model.predict(X_test)
Error Metrics for Regression¶
- Mean Absolute Error (MAE):
$$MAE = \dfrac{1}{n}\times|\sum_{i = 1}^{n}y_{i} - \hat{y_{i}}|$$
- Mean Squared Error (MSE):
$$MSE = \dfrac{1}{n}\times(\sum_{i = 1}^{n}y_{i} - \hat{y_{i}})^2$$
- Root Mean Squared Error (RMSE):
$$RMSE = \sqrt{\dfrac{1}{n}\times(\sum_{i = 1}^{n}y_{i} - \hat{y_{i}})^2}$$
- Mean Absolute Percentage Error (MAPE):
$$MAPE = \dfrac{100}{n}\times\mid\dfrac{\sum_{i = 1}^{n}y_{i} - \hat{y_{i}}}{y_{i}}\mid$$
In [256]:
print('The Mean absolute error on train data: {} \n'.format(mean_absolute_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute error on test data: {} \n'.format(mean_absolute_error(y_pred = y_test_pred, y_true = y_test)))
def mean_absolute_percentage_error(y_true, y_pred):
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
print('The Mean absolute percentage error on train data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute percentage error on test data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_test_pred, y_true = y_test)))
print('The R2 Score on train data: {} \n'.format(r2_score(y_pred = y_train_pred, y_true = y_train)))
print('The R2 Score on test data: {} \n'.format(r2_score(y_pred = y_test_pred, y_true = y_test)))
Decision Tree Model using Grid-search¶
Parameters¶
max_depth : int or None, optional (default=None)
The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples.
In [287]:
# set of parameters to test
param_grid = {'max_depth': range(1,11)}
In [288]:
dt = tree.DecisionTreeRegressor()
GS = GridSearchCV(dt, param_grid, cv=10)
GS.fit(X_train, y_train)
Out[288]:
In [289]:
GS.best_params_
Out[289]:
In [291]:
importances = GS.best_estimator_.feature_importances_
indices = np.argsort(importances)[::-1]
pd.DataFrame([car_Data_Scaled.columns[indices],np.sort(importances)[::-1]])
Out[291]:
In [292]:
dot_data = tree.export_graphviz(GS.best_estimator_, out_file=None, feature_names=car_Data_Scaled.drop(labels=['price'],axis=1).columns,class_names='price', filled=True, rounded=True, special_characters=True)
graph = graphviz.Source(dot_data)
graph
Out[292]:
In [294]:
y_train_pred = GS.predict(X_train)
y_test_pred = GS.predict(X_test)
In [295]:
print('The Mean absolute error on train data: {} \n'.format(mean_absolute_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute error on test data: {} \n'.format(mean_absolute_error(y_pred = y_test_pred, y_true = y_test)))
def mean_absolute_percentage_error(y_true, y_pred):
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
print('The Mean absolute percentage error on train data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute percentage error on test data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_test_pred, y_true = y_test)))
print('The R2 Score on train data: {} \n'.format(r2_score(y_pred = y_train_pred, y_true = y_train)))
print('The R2 Score on test data: {} \n'.format(r2_score(y_pred = y_test_pred, y_true = y_test)))
After, all the experience as a data scientist, I know that tree based ensembling models like Random Forest, xgboost will perform better in most of the situations as well as keeping the model simple by adding regularization and as well as fast during production by the use of GPU's.
Random Forest Model using Grid Search¶
Parameters¶
n_estimators : integer, optional (default=10).
The number of trees in the forest.
max_depth : integer or None, optional (default=None)
The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples.
max_features : int, float, string or None, optional (default=”auto”)
The number of features to consider when looking for the best split.
min_samples_leaf : int, float, optional (default=1)
The minimum number of samples required to be at a leaf node
In [296]:
# set of parameters to test
param_grid = {
"n_estimators" : [250, 300],
"max_depth" : [1,5,10],
"max_features" : [3, 5],
"min_samples_leaf" : [1, 2, 4, 6, 8, 10]}
In [297]:
rf = RandomForestRegressor()
GS = GridSearchCV(rf, param_grid, cv=10)
GS.fit(X_train, y_train)
Out[297]:
In [298]:
GS.best_params_
Out[298]:
In [299]:
y_train_pred = GS.predict(X_train)
y_test_pred = GS.predict(X_test)
In [300]:
print('The Mean absolute error on train data: {} \n'.format(mean_absolute_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute error on test data: {} \n'.format(mean_absolute_error(y_pred = y_test_pred, y_true = y_test)))
def mean_absolute_percentage_error(y_true, y_pred):
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
print('The Mean absolute percentage error on train data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute percentage error on test data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_test_pred, y_true = y_test)))
print('The R2 Score on train data: {} \n'.format(r2_score(y_pred = y_train_pred, y_true = y_train)))
print('The R2 Score on test data: {} \n'.format(r2_score(y_pred = y_test_pred, y_true = y_test)))
Xgboost Model¶
In [257]:
def runXGB(train_X, train_y, test_X, test_y=None):
params = {}
params["objective"] = "reg:linear"
params["eta"] = 0.002
params["min_child_weight"] = 1
params["subsample"] = 0.9
params["colsample_bytree"] = 0.8
params["silent"] = 1
params["max_depth"] = 8
params["seed"] = 1
plst = list(params.items())
num_rounds = 2500
xgtrain = xgb.DMatrix(train_X, label=train_y, feature_names=cols[cols!='price'])
xgtest = xgb.DMatrix(test_X, feature_names=cols[cols!='price'])
model = xgb.train(plst, xgtrain, num_rounds)
pred_test_y = model.predict(xgtest)
return pred_test_y, model
In [258]:
y_train_pred, model = runXGB(np.array(X_train), y_train, np.array(X_train))
y_test_pred, model = runXGB(np.array(X_train), y_train, np.array(X_test))
In [259]:
print('The Mean absolute error on train data: {} \n'.format(mean_absolute_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute error on test data: {} \n'.format(mean_absolute_error(y_pred = y_test_pred, y_true = y_test)))
def mean_absolute_percentage_error(y_true, y_pred):
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
print('The Mean absolute percentage error on train data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute percentage error on test data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_test_pred, y_true = y_test)))
print('The R2 Score on train data: {} \n'.format(r2_score(y_pred = y_train_pred, y_true = y_train)))
print('The R2 Score on test data: {} \n'.format(r2_score(y_pred = y_test_pred, y_true = y_test)))
In [260]:
fig, ax = plt.subplots(figsize=(12,18))
xgb.plot_importance(model, max_num_features=50, height=0.8, ax=ax)
plt.show()
In [261]:
xgb.to_graphviz(model,)
Out[261]:
SHAP (SHapley Additive exPlanations) is a unified approach to explain the output of any machine learning model. SHAP connects game theory with local explanations, uniting several previous methods [1-7] and representing the only possible consistent and locally accurate additive feature attribution method based on expectations (see the SHAP NIPS paper for details). Link : https://github.com/slundberg/shap
In [204]:
# load JS visualization code to notebook
shap.initjs()
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(pd.DataFrame(X_train, columns=cols[cols!='price']))
# visualize the first prediction's explanation
shap.force_plot(explainer.expected_value, shap_values[0,:], pd.DataFrame(X_train, columns=cols[cols!='price']).iloc[0,:])
Out[204]:
The above explanation shows features each contributing to push the model output from the base value (the average model output over the training dataset we passed) to the model output. Features pushing the prediction higher are shown in red, those pushing the prediction lower are in blue.
In [208]:
shap.summary_plot(shap_values, pd.DataFrame(X_train, columns=cols[cols!='price']))
To get an overview of which features are most important for a model we can plot the SHAP values of every feature for every sample. The plot below sorts features by the sum of SHAP value magnitudes over all samples, and uses SHAP values to show the distribution of the impacts each feature has on the model output. The color represents the feature value (red high, blue low). This reveals for example that a high curb-weight increases the predicted car price.
In [193]:
sns.scatterplot(car_Data['engine-size'], car_Data['curb-weight'], hue=car_Data['price'])
Out[193]:
Using the above plots, we can infer that the price of a car can be predicted just by using the curb-weight and engine-size with less error.
We can remove insurance-related features like symbolling and normalized-losses in predicting the price of a car. In-turn, we can use price, symboling and normalized-losses to buy a car from a seller.
Building a regression model to predict the normalized-losses¶
Split the data into Train and Test
In [262]:
X, y = car_Data_Scaled.loc[:, [x for x in car_Data_Scaled.columns if x not in ['normalized-losses','price','symboling_-1','symboling_0', 'symboling_1', 'symboling_2','symboling_3']]].values, car_Data_Scaled.loc[:,'normalized-losses'].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=15)
In [263]:
def runXGB(train_X, train_y, test_X, test_y=None):
params = {}
params["objective"] = "reg:linear"
params["eta"] = 0.002
params["min_child_weight"] = 1
params["subsample"] = 0.9
params["colsample_bytree"] = 0.8
params["silent"] = 1
params["max_depth"] = 8
params["seed"] = 1
plst = list(params.items())
num_rounds = 2500
xgtrain = xgb.DMatrix(train_X, label=train_y, feature_names=[x for x in car_Data_Scaled.columns if x not in ['normalized-losses','price','symboling_-1','symboling_0', 'symboling_1', 'symboling_2','symboling_3']])
xgtest = xgb.DMatrix(test_X, feature_names=[x for x in car_Data_Scaled.columns if x not in ['normalized-losses','price','symboling_-1','symboling_0', 'symboling_1', 'symboling_2','symboling_3']])
model = xgb.train(plst, xgtrain, num_rounds)
pred_test_y = model.predict(xgtest)
return pred_test_y, model
In [264]:
y_train_pred, model = runXGB(np.array(X_train), y_train, np.array(X_train))
y_test_pred, model = runXGB(np.array(X_train), y_train, np.array(X_test))
In [265]:
print('The Mean absolute error on train data: {} \n'.format(mean_absolute_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute error on test data: {} \n'.format(mean_absolute_error(y_pred = y_test_pred, y_true = y_test)))
def mean_absolute_percentage_error(y_true, y_pred):
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
print('The Mean absolute percentage error on train data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_train_pred, y_true = y_train)))
print('The Mean absolute percentage error on test data: {} \n'.format(mean_absolute_percentage_error(y_pred = y_test_pred, y_true = y_test)))
print('The R2 Score on train data: {} \n'.format(r2_score(y_pred = y_train_pred, y_true = y_train)))
print('The R2 Score on test data: {} \n'.format(r2_score(y_pred = y_test_pred, y_true = y_test)))
In [266]:
fig, ax = plt.subplots(figsize=(12,18))
xgb.plot_importance(model, max_num_features=50, height=0.8, ax=ax)
plt.show()
In [267]:
xgb.to_graphviz(model)
Out[267]:
In [268]:
# load JS visualization code to notebook
shap.initjs()
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(pd.DataFrame(X_train, columns=[x for x in car_Data_Scaled.columns if x not in ['normalized-losses','price','symboling_-1','symboling_0', 'symboling_1', 'symboling_2','symboling_3']]))
# visualize the first prediction's explanation
shap.force_plot(explainer.expected_value, shap_values[0,:], pd.DataFrame(X_train, columns=[x for x in car_Data_Scaled.columns if x not in ['normalized-losses','price','symboling_-1','symboling_0', 'symboling_1', 'symboling_2','symboling_3']]).iloc[0,:])
Out[268]:
In [269]:
shap.summary_plot(shap_values, pd.DataFrame(X_train, columns=[x for x in car_Data_Scaled.columns if x not in ['normalized-losses','price','symboling_-1','symboling_0', 'symboling_1', 'symboling_2','symboling_3']]))
This reveals that a high height increases the normalized-losses.